package futbol.tacticas.concursantes.TacticaCaccy;

import static java.lang.Math.*;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.Arrays;

import javax.swing.text.Position;

import futbol.Futbol;
import futbol.General;
import futbol.tacticas.ComandoGolpearBola;
/**
 * 
 * 
 * @author CACCY
 *
 */
public abstract class FutbolTools {

	//private static Logger 					log	= Logger.getLogger(FutbolTools.class);
	
	
	
	public static Ball calculTrajectoriaSegunPuntoDestino(Skills jugador, Ball pelota, ArrayList<Ball> trayecto, Point2D puntoDestino){
		
		double []puntoPreciso = toquePreciso(jugador,pelota,puntoDestino.getX(), puntoDestino.getY());
		Ball pelotaHipotetica = FutbolTools.createPelotaSegunDestino(jugador, jugador.fuerza , pelota, puntoPreciso[0], puntoPreciso[1]);
		if(trayecto == null)
			trayecto = new ArrayList<Ball>();
		FutbolTools.calculTrajectoria(pelotaHipotetica, trayecto);
		
		return FutbolTools.calculTrajectoria(pelotaHipotetica, trayecto);
	}
	
	public static Ball calculTrajectoriaSegunJugadorDestino(Skills jugador, Ball pelota, ArrayList<Ball> trayecto, int indiceJugadorDestino){
		//Personalitat jugadorDestino = jugador.tecnico.getAlineacion()[indiceJugadorDestino];
		double []puntoPreciso = pasePreciso(jugador,pelota,indiceJugadorDestino);
		Ball pelotaHipotetica = FutbolTools.createPelotaSegunDestino(jugador, jugador.fuerza , pelota, puntoPreciso[0], puntoPreciso[1]);
		if(trayecto == null)
			trayecto = new ArrayList<Ball>();
		FutbolTools.calculTrajectoria(pelotaHipotetica, trayecto);
		
		return FutbolTools.calculTrajectoria(pelotaHipotetica, trayecto);
	}
	
	public static Ball calculTrajectoria(Ball pelota, ArrayList<Ball> trayecto){
		Ball pT = null;
		Ball primeraChutable = null;
		int index = 0;
		
		if(trayecto==null){
			trayecto = new ArrayList<Ball>();
		}
		trayecto.clear();
		pT=moverPelota(pelota);
		trayecto.add(index,pT); 
		index++;
		if(Math.round(pT.velocidad)<15&&primeraChutable==null){
			primeraChutable = pT.getCopia();
		}
		if(pT.isPelotaConPeligroDeGol()!=-1){
			return primeraChutable;
		}
		
		while(((int)Math.round(pT.velocidad))>0)
		{
		
			pT=moverPelota(pT);
			trayecto.add(pT);
			index++;
			if(Math.round(pT.velocidad)<15&&primeraChutable==null){
				primeraChutable = pT.getCopia();
			}
			if(pT.isPelotaConPeligroDeGol()!=-1){
				return primeraChutable;
			}
		}

		return primeraChutable;
	}
	

	private static Ball  moverPelota(Ball pelotaOrigen)
	{
		boolean rebote = false;

		Ball p = new Ball(pelotaOrigen.x,pelotaOrigen.y, pelotaOrigen.velocidad,pelotaOrigen.angulo);
		Ball posiblePuntoDeGol = p.getCopia();
		
		for (int n=0;n<(int)Math.round(p.velocidad)&&Manager.esGol(p)==-1;n++){
			p.x+=Math.cos(p.angulo);
			p.y+=Math.sin(p.angulo);
			
			if (Manager.esGol(p)==-1){
				if (p.x>160){
					p.x=320-p.x;  //160 - (x-160)
					p.angulo=General.corregirAngulo(Math.PI-p.angulo);
					rebote = true;
				}
				if (p.x<-160){
					p.x=-320-p.x; //-160 + (-160-x)
					p.angulo=General.corregirAngulo(Math.PI-p.angulo);
					rebote = true;
				}
				if (p.y>120){
					p.y=240-p.y; //120 - (x-120)
					p.angulo=General.corregirAngulo(-p.angulo);
					rebote = true;
				}
				if (p.y<-120){
					p.y=-240-p.y;  //-120 + (-120-x)
					p.angulo=General.corregirAngulo(-p.angulo);
					rebote = true;
				}
				
				
			}
		}
	
		if ((int)Math.round(p.velocidad)>0) p.velocidad--;
		
		if(Manager.esGol(p)!=-1){
			posiblePuntoDeGol.setPelotaConPeligroDeGol(Manager.esGol(p));
			posiblePuntoDeGol.setHaRebotado(rebote);
			return posiblePuntoDeGol.getCopia();
		}
		
		p.setHaRebotado(rebote);
		
		return p;
		
	}
	
	
	
		public static  int getFuerzaEfectivaSegunDestino(int fuerzaDelJugador, Point2D posicionJugadorOrigen,  double xDestino, double yDestino){		
	
		double distancia = posicionJugadorOrigen.distance(xDestino,yDestino);
		double fuerza = fuerzaDelJugador;
		int nGrado;
		
		
		if(distancia<50){
			nGrado = (int)(distancia*2);
			int fuerza_efectiva = (int)(fuerza*nGrado/100);
			return fuerza_efectiva;
		}
		
		return fuerzaDelJugador;
	}
	
		public static int getVelocidadEfectivaSegunDestino(Point2D jugadorOrigen, int fuerzaJugador, double xDestino, double yDestino){
		
		return 3*getFuerzaEfectivaSegunDestino(fuerzaJugador, jugadorOrigen,  xDestino,  yDestino);
	}
	
	
		public static Ball createPelotaSegunDestino(Point2D jugadorOrigen, int fuerzaJugador, Ball pelotaOrigen,  double xDestino, double yDestino){
		Ball pelota = null;
		
		
		double angulo = calcAngulo(pelotaOrigen, xDestino, yDestino);
		
		pelota = new Ball(pelotaOrigen.x, pelotaOrigen.y , getVelocidadEfectivaSegunDestino(jugadorOrigen, fuerzaJugador, xDestino,  yDestino),angulo);
		
		return pelota;
	}

	 public static double calcAngulo(Point2D pOrigen, Point2D pDestino){
		 return calcAngulo(pOrigen.getX(), pOrigen.getY(), pDestino.getX(), pDestino.getY());
	 }
	
		 public static double calcAngulo(Point2D pelotaOrigen , double xDestino, double yDestino){
		 
		 return calcAngulo(pelotaOrigen.getX(), pelotaOrigen.getY(), xDestino, yDestino);
	 }
	 
		 public static double calcAngulo(double xOrigen, double yOrigen , double xDestino, double yDestino){
		 	double vectorX = xDestino-xOrigen;
			double vectorY = yDestino-yOrigen;

			if(((xDestino==xOrigen)&&(yDestino==yOrigen))&&xDestino==0){
				return 0;
			}
			if(vectorX==0&&vectorY==0){
				return 0;
			}
			
			return General.corregirAngulo(Math.atan2(vectorY,vectorX));
	 }
	 
	 public static double calcAnguloPI(double xOrigen, double yOrigen , double xDestino, double yDestino){
		 	double vectorX = xDestino-xOrigen;
			double vectorY = yDestino-yOrigen;

			if(((xDestino==xOrigen)&&(yDestino==yOrigen))&&xDestino==0){
				return 0;
			}
			if(vectorX==0&&vectorY==0){
				return 0;
			}
			
			return Math.atan2(vectorY,vectorX);
	 }
	 
	 public static double corregirAnguloPI(double ang){
	        while (ang<0)
	            ang+=Math.PI*2;
	        while (ang>=Math.PI*2)
	            ang-=Math.PI*2;
	        return ang;
	    }
	 

	 
		 public static boolean estaEnVector(int vector[], int num){
		 if (vector==null) return false;
		 for (int n=0;n<vector.length;n++)
			 if (vector[n]==num)
				 return true;
		 return false;
	 }
	 
	 
		 public static Double getDistanciaCritica(int fuerza) {
		 switch (fuerza) {
		 case 7:
			 return 126.0;
		 case 6:
			 return 66.0;
		 case 5:
			 return 15.0;
		 default:
			 return 0.0;
		 }
	 }
	 
	 
		 private static double[] calculEcuacio2nGrau(double A, double B, double C){
		 double [] x = new double[2];
		 double arrel;
		 
		 arrel = Math.sqrt(B*B-4*A*C);
		 
		 //if(Double.isInfinite(arrel))
		 //	 log.error("arrel es Infinite");

		 //if(Double.isNaN(arrel))
		 //	 log.error("arrel es NaN");
		 
		 
		 x[0] = (-B+arrel)/(2*A);
		 x[1] = (-B-arrel)/(2*A);
		 
		 return x;
	 }

	 	public static double [] pasePreciso(Skills jugadorOrigen, Ball pelotaOrigen , int indexJugadorDestion)
		{
			Manager tecnico = jugadorOrigen.tecnico;
			double [] pasePreciso = new double[2];
			int fuerzaDelJugador = jugadorOrigen.getFuerza();
			
			double xDestino = tecnico.getUltimaSJ().getMisJugadores()[indexJugadorDestion].getX();
			double yDestino = tecnico.getUltimaSJ().getMisJugadores()[indexJugadorDestion].getY();
			
			pasePreciso[0] = xDestino;
			pasePreciso[1] = yDestino;
			
			
			ArrayList<Ball> trayectoriaHipotetica = new ArrayList<Ball>();
			Ball pelotaHipotetica = null;
			Ball pelotaChutableHipotetica = null;
			
			int fuerzaIdeal = 0;
			int fuerzaHipotetica = 0;
			int fuerzaReducida = 0;
			double error_minimo = 9999;
			double error_actual = 0;
			
			fuerzaIdeal=fuerzaHipotetica=fuerzaDelJugador;
			
			double anguloHipoteticoPel = calcAngulo(pelotaOrigen,xDestino,yDestino);
			
				
			int xMaximo = (int)Math.round(pelotaOrigen.x+60*Math.cos(anguloHipoteticoPel));
			int yMaximo = (int)Math.round(pelotaOrigen.y+60*Math.sin(anguloHipoteticoPel));
			
			pelotaHipotetica = createPelotaSegunDestino(jugadorOrigen, jugadorOrigen.getFuerza() ,pelotaOrigen,   xMaximo,  yMaximo);
			pelotaChutableHipotetica = calculTrajectoria(pelotaHipotetica,trayectoriaHipotetica);
			
			if(pelotaChutableHipotetica == null){
				return pasePreciso;
			}
			
			error_minimo = pelotaChutableHipotetica.distance(xDestino,yDestino);

		
			for(fuerzaHipotetica--; fuerzaHipotetica>0&& error_actual<=error_minimo; fuerzaHipotetica--){
				
				//log.debug("fuerzaHipotetica: "+fuerzaHipotetica);
				
				pelotaHipotetica = createPelotaSegunDestino(jugadorOrigen, fuerzaHipotetica,  pelotaOrigen,   xMaximo,  yMaximo);
				pelotaChutableHipotetica = calculTrajectoria(pelotaHipotetica,trayectoriaHipotetica);
				error_actual = pelotaChutableHipotetica.distance(xDestino,yDestino);
				
				if(error_actual<error_minimo){
					error_minimo=error_actual;
					fuerzaIdeal = fuerzaHipotetica;
				}
			}
			
			boolean contrariEnTrajectoria = true;
			for(fuerzaHipotetica=fuerzaIdeal ; fuerzaHipotetica>0&& contrariEnTrajectoria; fuerzaHipotetica--){
			
				contrariEnTrajectoria = tecnico.contrariEnTrajectoriaPuntoPreciso(jugadorOrigen, fuerzaHipotetica, pelotaOrigen, indexJugadorDestion)<1;
				
				if(!contrariEnTrajectoria){
					fuerzaReducida = fuerzaHipotetica;
				}
			}
			
			if(!contrariEnTrajectoria){
				fuerzaIdeal = fuerzaReducida;
			}
			
			int offset = 1;
			double distanciaRealJugador = 55; //Distancia per for�a total =  50 per curarnos en salud --> 51
			if(fuerzaIdeal<fuerzaDelJugador){
				distanciaRealJugador = ((double)fuerzaIdeal/(double)fuerzaDelJugador)*50+offset;
				distanciaRealJugador = trimDistanciasPosibles(distanciaRealJugador);
				
			}
			
			
			pasePreciso = calculaPuntoPreciso(jugadorOrigen.getPointAcutal(), pelotaOrigen.getPoint2D(), xDestino, yDestino, distanciaRealJugador);
			
			double a = Math.toDegrees(anguloHipoteticoPel);
			double b = Math.toDegrees(calcAngulo(pelotaOrigen, pasePreciso[0], pasePreciso[1]));
			
			
			if((Math.floor(a))!=(Math.floor(b))){
				}
			
			
			
			
			return pasePreciso;
		}
		
		
			public static double [] toquePreciso(Skills jugadorOrigen, Ball pelotaOrigen , double xDestino, double yDestino)
		{
			double [] pasePreciso = new double[2];
			int fuerzaDelJugador = jugadorOrigen.getFuerza();
			
			pasePreciso[0] = xDestino;
			pasePreciso[1] = yDestino;
			
			
			ArrayList<Ball> trayectoriaHipotetica = new ArrayList<Ball>();
			Ball pelotaHipotetica = null;
			Ball pelotaChutableHipotetica = null;
			
			int fuerzaIdeal = 0;
			int fuerzaHipotetica = 0;
			int fuerzaReducida = 0;
			double error_minimo = 9999;
			double error_actual = 0;
			
			fuerzaIdeal=fuerzaHipotetica=fuerzaDelJugador;
			
			double anguloHipoteticoPel = calcAngulo(pelotaOrigen,xDestino,yDestino);
			
				
			int xMaximo = (int)Math.round(pelotaOrigen.x+60*Math.cos(anguloHipoteticoPel));
			int yMaximo = (int)Math.round(pelotaOrigen.y+60*Math.sin(anguloHipoteticoPel));
			
			pelotaHipotetica = createPelotaSegunDestino(jugadorOrigen, jugadorOrigen.fuerza ,pelotaOrigen,   xMaximo,  yMaximo);
			pelotaChutableHipotetica = calculTrajectoria(pelotaHipotetica,trayectoriaHipotetica);
			
			if(pelotaChutableHipotetica == null){
				return pasePreciso;
			}
			
			error_minimo = pelotaChutableHipotetica.distance(xDestino,yDestino);
			
			for(fuerzaHipotetica--; fuerzaHipotetica>0&& error_actual<=error_minimo; fuerzaHipotetica--){
				
				pelotaHipotetica = createPelotaSegunDestino(jugadorOrigen, fuerzaHipotetica,  pelotaOrigen,   xMaximo,  yMaximo);
				pelotaChutableHipotetica = calculTrajectoria(pelotaHipotetica,trayectoriaHipotetica);
				error_actual = pelotaChutableHipotetica.distance(xDestino,yDestino);
				
				if(error_actual<error_minimo){
					error_minimo=error_actual;
					fuerzaIdeal = fuerzaHipotetica;
				}
			
			}
			
			int offset = 1;
			double distanciaRealJugador = 55; //Distancia per for�a total =  50 per curarnos en salud --> 51
			if(fuerzaIdeal<fuerzaDelJugador){
				distanciaRealJugador = ((double)fuerzaIdeal/(double)fuerzaDelJugador)*50+offset;
				distanciaRealJugador = trimDistanciasPosibles(distanciaRealJugador);
				
			}
			
			
			pasePreciso = calculaPuntoPreciso(jugadorOrigen.getPointAcutal(), pelotaOrigen.getPoint2D(), xDestino, yDestino, distanciaRealJugador);
			
			double a = Math.toDegrees(anguloHipoteticoPel);
			double b = Math.toDegrees(calcAngulo(pelotaOrigen, pasePreciso[0], pasePreciso[1]));
			
			
			if((Math.floor(a))!=(Math.floor(b))){
			}
			
			
		
			
			
			return pasePreciso;
		}
		
	 
	 
	 

	
	private static double[] calculaPuntoPreciso(Point2D puntoJugador, Point2D puntoPelota, double xDestino, double yDestino, double radio){
		double [] puntoPreciso = new double[2];
		double [] xAux = null;
		double [] point0 = new double[2];
		double [] point1 = new double[2];
		double M,A,a,b,r, Q, R, S,v,h,error0,error1;
		
		
		if(radio<puntoPelota.distance(puntoJugador)){
			puntoPreciso[0] = puntoPelota.getX();
			puntoPreciso[1] = puntoPelota.getY();
			return puntoPreciso;
		}
		
		
		a = puntoJugador.getX();
		b = puntoJugador.getY();
		r = radio;
		
		v = yDestino - puntoPelota.getY();
		h = xDestino - puntoPelota.getX();
		//if(Double.isNaN(v))
		//	log.error("v is NaN");
		//if(Double.isNaN(h))
		//	log.error("h is NaN");
		
		M = v/h;
		if(Double.isNaN(M)){
			
			M=0;
		}
		if(Double.isInfinite(M)){
			
			M=999999;
		}
		
		A = puntoPelota.getY() - (puntoPelota.getX()*M);

		//if(Double.isNaN(A))
		//	log.error("A is NaN");
		
		Q = (1+(M*M));
		R = 2*(M*A-M*b-a);
		S = (b*b+a*a+A*A-(r*r)-(2*A*b));
		
		//if(Double.isNaN(Q))
		//	log.error("Q is NaN");
		//if(Double.isNaN(R))
		//	log.error("R is NaN");
		//if(Double.isNaN(S))
		//	log.error("S is NaN");
		
		
		xAux = calculEcuacio2nGrau(Q,R,S);
		
	
	
		
		point0[0] = xAux[0];
		point0[1] = (M*xAux[0]+A);
		point1[0] = xAux[1];
		point1[1] = (M*xAux[1]+A);
		
		//if(Double.isNaN(xAux[0])&&Double.isNaN(xAux[1])){
		//	log.error(" point0["+(int)point0[0]+","+(int)point0[1]+"]");
		//	log.error(" point1["+(int)point1[0]+","+(int)point1[1]+"]");
		//}
		
		double anguloDeseado = calcAngulo(puntoPelota, xDestino, yDestino);
		
			
		
		error0 = Math.abs(anguloDeseado-calcAngulo(puntoPelota,point0[0],point0[1]));
		error1 = Math.abs(anguloDeseado-calcAngulo(puntoPelota,point1[0],point1[1]));
		
		if(Double.isNaN(xAux[0])&&Double.isNaN(xAux[1])){
			//log.error("xAux is NaN");
			//log.error("angul_deseado: "+toDegrees(anguloDeseado));
			//log.error("pilota: ["+puntoPelota.getX()+","+puntoPelota.getY()+"]   destino: ["+xDestino+","+yDestino+"]    jugador: ["+puntoJugador.getX()+","+puntoJugador.getY()+"]");
			//log.error("error0="+error0+" ang:"+Math.toDegrees(calcAngulo(puntoPelota,point0[0],point0[1]))+ " point0["+(int)point0[0]+","+(int)point0[1]+"]");
			//log.error("error1="+error1+" ang:"+Math.toDegrees(calcAngulo(puntoPelota,point1[0],point1[1]))+ " point1["+(int)point1[0]+","+(int)point1[1]+"]  radio:"+radio);
		}
		
		//if(error0>0.00001&&error1>0.00001){
		//	log.error("angul_deseado: "+anguloDeseado);
		//	log.error("error0="+error0+" ang:"+Math.toDegrees(calcAngulo(puntoPelota,point0[0],point0[1]))+ " point0["+(int)point0[0]+","+(int)point0[1]+"]");
		//	log.error("error1="+error1+" ang:"+Math.toDegrees(calcAngulo(puntoPelota,point1[0],point1[1]))+ " point1["+(int)point1[0]+","+(int)point1[1]+"]");
		//	log.error("pilota: ["+puntoPelota.getX()+","+puntoPelota.getY()+"]   destino: ["+xDestino+","+yDestino+"]    jugador: ["+puntoJugador.getX()+","+puntoJugador.getY()+"]  radio:"+radio+" dist:"+puntoJugador.distance(puntoPelota));
		//}
		
		if((error0<error1)&&(error0<0.00001)){
			puntoPreciso = point0;
		}else if((error1<error0)&&(error1<0.00001)){
			puntoPreciso = point1;
		}else{
			
			error0 = Math.hypot((xDestino-point0[0]),(yDestino-point0[1]));
			error1 = Math.hypot((xDestino-point1[0]),(yDestino-point1[1]));
			//log.error("Decision x distancia");
			
			if(error0<error1){
				puntoPreciso = point0;
				//log.error("Gana point 0");
			}else if(error1<error0){
				puntoPreciso = point1;
				//log.error("Gana point 0");
			}else{
				puntoPreciso = point0;
			}

		}
		
		error1 = Math.abs(anguloDeseado-calcAngulo(puntoPelota,puntoPreciso[0],puntoPreciso[1]));
		if(error1>0.00001){
			//log.error("NOOOO - anguloDeseado:"+Math.toDegrees(anguloDeseado)+" angulo_final="+Math.toDegrees(calcAngulo(puntoPelota,puntoPreciso[0],puntoPreciso[1]))+"\n");
			
			
			
		}
		
		return puntoPreciso;
	}
	
	
	private static double trimDistanciasPosibles(double distanciaRealJugador){
		if(distanciaRealJugador>42.85&&distanciaRealJugador<44){
			
			distanciaRealJugador=44;
		}
		
		if(distanciaRealJugador>41.667&&distanciaRealJugador<42.5){
			
			distanciaRealJugador=42.5;
		}
		
		if(distanciaRealJugador>40&&distanciaRealJugador<41){
			
			distanciaRealJugador=41;
		}
		
		if(distanciaRealJugador>35.72&&distanciaRealJugador<38){
			
			distanciaRealJugador=38;
		}
		if(distanciaRealJugador>33.334&&distanciaRealJugador<34){
			
			distanciaRealJugador=34;
		}
		
		return distanciaRealJugador;
	}
	
	public static int distanciaMaximaDePelota(int fuerzaDeJugador){
		int distancia = 0;
		for(int i=0; i<=fuerzaDeJugador*3; i++)
			distancia+=i;
		
		return distancia;
	}
	
	
	public static int turnosHastaPunto(Point2D puntoJugador, int velocidad, Point2D puntoDestino){
		return turnosHastaPunto(puntoJugador, velocidad, puntoDestino, 10);
	}
	
	public static int turnosHastaPunto(Point2D puntoJugador, int velocidad, Point2D puntoDestino, int humbral){
		return (int) (puntoJugador.distance(puntoDestino)-humbral)/ velocidad;
	}
	
	public static int turnosHastaPunto(double jx, double jy, int velocidad, double px, double py){
		return turnosHastaPunto(new Point2D.Double(jx,jy), velocidad, new Point2D.Double(px,py));
	}
	public static double[] arrayCopy (double[] original, int newLength) {
        double[] copy = new double[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
	public static int[] arrayCopy (int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
	public static Play[] arrayCopy (Play[] original, int newLength) {
		Play[] copy = new Play[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
	
	public static double[][] arrayCopy (double[][] original, int newLength) {
        double[][] copy = new double[newLength][];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
	public static double aA(double angulo, double anguloDeseado){
		
		while(angulo>anguloDeseado+PI){
			angulo -= 2*PI;
		}
		
		while(angulo<anguloDeseado-PI){
			angulo += 2*PI;
		}

		return angulo;
	}
	
	public static int getCuadrante(double angulo){
		
		if(sin(angulo)>=0&&cos(angulo)>=0){
			return 1;
		}else if(sin(angulo)>=0&&cos(angulo)<0){
			return 2;
		}else if(sin(angulo)<0&&cos(angulo)<0){
			return 3;
		}else if(sin(angulo)<0&&cos(angulo)>=0){
			return 4;
		}
		
		return 1;
	
	}
	public static double[] toquePrecisoSinParedes(Skills jugadorOrigen, Ball bolaHipotetica, Point2D puntoDestino){
		double offset = 0;
		double p[]=null;
		
		if(puntoDestino!=null)
		{
			if(bolaHipotetica.getY()<0){
				offset = -(120+puntoDestino.getY());
			}else{
				offset = 120 - puntoDestino.getY();
			}
			jugadorOrigen.y += offset;
			bolaHipotetica.y += offset;
			p = FutbolTools.toquePreciso(jugadorOrigen, bolaHipotetica, puntoDestino.getX(), puntoDestino.getY()+offset);
			jugadorOrigen.y -= offset;
			bolaHipotetica.y -= offset;
			p[1] -= offset;
		}
		return p;
	}
	public static double[][] getPosicionesIniciales(int numJugadores)
	{
		double[][] posicionesIniciales = new double[numJugadores][2];
		
		
		
		
		
		return posicionesIniciales;
	}
}
